/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package ctrl.jeu;

import java.awt.Container;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.FilteredImageSource;
import java.util.ArrayList;
import javax.swing.ImageIcon;
import ctrl.sys.ClientSend;
import ctrl.sys.Const;
import ctrl.sys.Demande;
import ctrl.sys.clientTCP;
import view.ihm.imageTransp;
import view.ihm.panTexteAction;

/**
 *
 * @author Willy
 */
public class Table {
    private int Capacite=8;
    private int Id; // identifiant de la table
    private Place dealer;
    private float Blind;
    private int MontMinimumEntree;
    private int MontMaximumEntree;
    private ArrayList<Mise> mises;
    private ArrayList<Place> places;
    private ArrayList<Place> observateurs;
    private ArrayList<Chaise> chaises;
    public Container Fenetre;
    private Distribution d=new Distribution();
    private int x,y;
    //public static membre MembreCourant;
    public Place PlaceMain; // joueur connecté actuellement
    public Chaise ChaiseMain; // Chaise du joueur connecté actuellement
    public Image trans;
    public static int idcourant=0; //identifiant courant
    public boolean islaunch=false;
    public clientTCP ClientReseau;
    private ArrayList<Place> ParticipantTour;
    private Place EncoursDeJeu;
    private Carte[] Flop= new Carte[3];
    private Carte Tournant;
    private Carte Riviere;
    public Joueur Play;
    private boolean FinTour=false;
    public boolean Controlleur=false;
    private panTexteAction TexteAction;
    

    public Table(int id,int Blind, int MontMinimumEntree, int MontMaximumEntree) {
        this.Id=id;
        idcourant++;
        this.Blind = Blind;
        this.MontMinimumEntree = MontMinimumEntree;
        this.MontMaximumEntree = MontMaximumEntree;
        Play=new Joueur("","");
        ParticipantTour=new ArrayList<Place>();
        ImageIcon imgi=new javax.swing.ImageIcon(getClass().getResource("/img/table.png"));
        Image image = imgi.getImage();
        trans = Toolkit.getDefaultToolkit().createImage (new FilteredImageSource (image.getSource (), new imageTransp()));
        mises=new ArrayList<Mise>();
        places=new ArrayList<Place>();
        observateurs=new ArrayList<Place>();
        //places.add(new Place(100));
        //places.add(new Place(130));

        // lors de l'ajout des chaises, on doit toujours crée une chaise et ajouter (pour verifier la logique des id)
        chaises=new ArrayList<Chaise>();
        Chaise c1=new Chaise(-65,65, 80, 80,this,30,0);
        chaises.add(c1); // gauche
        //Chaise c2=new Chaise(840,65, 80, 80,this);
        Chaise c2=new Chaise(840,65, 80, 80,this,-30,0);
        //c2.CreeAction(places);
        System.out.println("places= "+places);
        chaises.add(c2); // droite
        /*chaises.add(new Chaise(-30,160, 80, 80,this)); // 1er bas
        chaises.add(new Chaise(120,180, 80, 80)); // 2e bas
        chaises.add(new Chaise(270,180, 80, 80)); // 3e bas
        chaises.add(new Chaise(420,160, 80, 80)); // 4e bas
        chaises.add(new Chaise(0,-80, 80, 80)); // 1er haut
        chaises.add(new Chaise(400,-80, 80, 80)); // 2e haut*/
        this.Capacite=places.size();
        
    }

    public panTexteAction getTexteAction() {
        return TexteAction;
    }

    public void setTexteAction(panTexteAction TexteAction) {
        this.TexteAction = TexteAction;
    }

    
    public boolean isFinTour() {
        return FinTour;
    }

    public void setFinTour(boolean FinTour) {
        this.FinTour = FinTour;
    }

    public void setPlaceMain(Place JoueurMain) {
        this.PlaceMain = JoueurMain;
    }

    public Place getPlaceMain() {
        return PlaceMain;
    }

    public int getId() {
        return Id;
    }

    public void setId(int Id) {
        this.Id = Id;
    }

    public Place getEncoursDeJeu() {
        return EncoursDeJeu;
    }

    public void setEncoursDeJeu(Place EncoursDeJeu) {
        this.EncoursDeJeu = EncoursDeJeu;
    }

    
    public ArrayList<Place> getPlaces() {
        return places;
    }

    public void setPlaces(ArrayList<Place> places) {
        this.places = places;
    }

    public ArrayList<Place> getObservateurs() {
        return observateurs;
    }

    public void setObservateurs(ArrayList<Place> observateur) {
        this.observateurs = observateur;
    }

    
    public Place getPlaces(int val) {

        Place fin=null;
        for(int i=0;i<places.size();i++)
        {
            if(places.get(i).getId()==val) fin=places.get(i);
        }
        return fin;
    }
    
    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }


    public float getBlind() {
        return Blind;
    }

    public void setBlind(float Blind) {
        this.Blind = Blind;
    }

    public int getCapacite() {
        return Capacite;
    }

    public void setCapacite(int Capacite) {
        this.Capacite = Capacite;
    }

    public Place getDealer() {
        return dealer;
    }

    public void setDealer(Place dealer) {
        this.dealer = dealer;
    }

    public Distribution getD() {
        return d;
    }

    public void setD(Distribution d) {
        this.d = d;
    }

    public ArrayList<Mise> getMises() {
        return mises;
    }

    public Mise getMises(Place p) {
        for(int i=0;i<getMises().size();i++)
        {
            if(getMises().get(i).getPlaces().equals(p)) return getMises().get(i);
        }
        return null;
    }

    public void setMises(ArrayList<Mise> mises) {
        this.mises = mises;
    }

    public Chaise getChaiseMain() {
        return ChaiseMain;
    }

    public void setChaiseMain(Chaise ChaiseMain) {
        this.ChaiseMain = ChaiseMain;
    }

    public clientTCP getClientReseau() {
        return ClientReseau;
    }

    public void setClientReseau(clientTCP ClientReseau) {
        this.ClientReseau = ClientReseau;
    }

    public int getMontMaximumEntree() {
        return MontMaximumEntree;
    }

    public void setMontMaximumEntree(int MontMaximumEntree) {
        this.MontMaximumEntree = MontMaximumEntree;
    }

    public int getMontMinimumEntree() {
        return MontMinimumEntree;
    }

    public void setMontMinimumEntree(int MontMinimumEntree) {
        this.MontMinimumEntree = MontMinimumEntree;
    }

    public ArrayList<Chaise> getChaises() {
        return chaises;
    }
    public Chaise getChaises(int idChaise) {
        for(int i=0;i<getChaises().size();i++)
        {
            if(idChaise==getChaises().get(i).getId()) return getChaises().get(i);
        }
        return null;
    }
    

    
    /**
     * Méthode qui charge le seed, c'est a dire qui fait le partage hasardeux des carte.
     * Cette méthode est executée uniquement lorsque la table est pleine
     */
    public void SetSeed()
    {
        d.ChargeCard();
        for(int j=0;j<2;j++)
            for(int i=0;i<places.size();i++)
            {
                Place p=(Place)places.get(i);
                p.getCard()[j]=d.Donne();
            }
    }
    public void SetFlop()
    {
        this.Flop[0]=d.Donne();
        this.Flop[1]=d.Donne();
        this.Flop[2]=d.Donne();
    }

    public void SetTournant()
    {
        this.Tournant=d.Donne();
    }

    public void SetRiviere()
    {
        this.Riviere=d.Donne();
    }

    public void setFlop(Carte[] Flop) {
        this.Flop = Flop;
    }

    public void setRiviere(Carte Riviere) {
        this.Riviere = Riviere;
    }

    public void setTournant(Carte Tournant) {
        this.Tournant = Tournant;
    }

    
    /**
     * Méthode qui permet de déclencher l'affichage des cartes
     */
    public void ShowCartePartage()
    {
        for(int j=0;j<2;j++)
            for(int i=0;i<Capacite;i++)
            {
                Chaise p=(Chaise)chaises.get(i);
                if(p.getLieu().equals(getPlaceMain()))
                {
                    p.getLieu().getCard()[j].AfficheMini(Fenetre,getX()+p.getX()+90+(j*25),getY()+p.getY()+25);
                    try { Thread.sleep(1000); } catch(Exception e) {}
                    Fenetre.repaint();
                }
            }
        islaunch=true;
    }


    public void Affiche(Container cont,int x,int y)
    {
        Graphics g=cont.getGraphics();
        setX(x);
        setY(y);
        Fenetre=cont;
        // insertion de l'image situé au centre
        //g.drawImage(trans,x, y,cont);


        // dessin des chaises (carré, compte a rebours, zone montant)
        for(int i=0;i<chaises.size();i++)
        {
            Chaise c=(Chaise)chaises.get(i);
            c.Affiche(cont,x,y,getPlaceMain());
            //p.getPan().repaint();
        }

        // si il y'a un flop on l'affiche
        if(getFlop()[0]!=null)
        {
            for(int i=0;i<3;i++)
            {
                Carte c=getFlop()[i];
                c.AfficheMini(cont, 300+x+(i*50), 100+y);
            }
        }
        // si il y'a un tournant on l'affiche
        if(getTournant()!=null) getTournant().AfficheMini(cont, 300+x+(3*50),100+y);

        // si il y'a une rivière on l'affiche
        if(getRiviere()!=null) getRiviere().AfficheMini(cont, 300+x+(4*50),100+y);

        // si on est a la fin d'un tour
        if(isFinTour())
        {
            //JOptionPane.showMessageDialog(cont, "Ce tour est achevé","Info",JOptionPane.INFORMATION_MESSAGE);

            try {Thread.sleep(2000); }catch (Exception e) {}
            Demande as=new Demande(Const.DEBUT,getId(),getPlaceMain().getIdChaise());
            new ClientSend(getClientReseau().getClient(), as).start();
        }
        
    }

    public void initParticipant()
    {
        this.ParticipantTour.addAll(getPlaces());
    }

    public ArrayList<Place> getParticipantTour() {
        return ParticipantTour;
    }

    public Carte[] getFlop() {
        return Flop;
    }

    public Carte getRiviere() {
        return Riviere;
    }

    public Carte getTournant() {
        return Tournant;
    }


    public void setParticipantTour(ArrayList<Place> ParticipantTour) {
        this.ParticipantTour = ParticipantTour;
    }

    
    @Override
    public String toString() {
        return getId()+" place: "+getPlaces()+" Chaise: "+getChaises();
    }

    /**
     * Méthode qui retourne une table correspondant a un numéro donné
     * @param tab Liste des tables présentes
     * @param num Numéro de la table recherchée
     * @return Table correspondante au numéro
     */
    public static Table getTable(ArrayList<Table> tab,int num)
    {
        Table fin=null;
        for(int i=0;i<tab.size();i++)
        {
            if(tab.get(i).getId()==num) fin=tab.get(i);
        }
        return fin;
    }

    public boolean isPlein()
    {
        return getChaises().size()==getPlaces().size();
    }


}
